perm filename DV.FIX[MF,ALS]4 blob
sn#786620 filedate 1985-02-25 generic text, type C, neo UTF8
COMMENT ⊗ VALID 00004 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00002 00002 @ @<Read the |boc| information@>=
C00022 00003 PREFERRED VERSIONS OF THE CHANGES ARE TO GO AHEAD OF THIS LINE.
C00037 00004 I wonder if you would care to comment on the following matter.
C00040 ENDMK
C⊗;
@ @<Read the |boc| information@>=
begin
char_code←gf_signed_quad;
p←gf_signed_quad;
c←char_code mod 256;
if c<0 then c←c+256;
{|print('[',c:1,']');|}
if char_code≠c then
print(' in family ',(char_code-c) div 256 : 1);
min_m←gf_signed_quad; max_m←gf_signed_quad;
min_n←gf_signed_quad; max_n←gf_signed_quad;
del_m←max_m-min_m;
del_n←max_n-min_n;
end
@ @<Read the |boc1| information@>=
begin
char_code←gf_byte;
p←-1;
c←char_code;
del_m←gf_byte; max_m←gf_byte;
del_n←gf_byte; max_n←gf_byte;
min_m←max_m-del_m;
end
@ @<Stow the |boc| or |boc1| information@>=
stow_signed_pair(del_m+1);
stow_signed_pair(-min_m); {this is the initial |m| value}
stow_signed_pair(del_n+1);
stow_signed_pair(max_n);
@p procedure skip_it; {to bypass the |fnt_def1| commands in the body}
var i,j,k: integer;
begin
for i←1 to 13 do j←get_byte;
j←j+get_byte;
if j>0 then for i←1 to j do k←get_byte;
end;
@<Glob...@>=
@!font_state:array[0..max_fonts] of integer; {0 unloaded, 1 loaded}
@!font_dir_size:array[0..max_fonts] of integer;
@!font_name_size:array[0..max_fonts] of integer;
@ Reusing font raster space.
It is usually not possible to provide a large enough |m_store| space
for all of the fonts that may be used in some documents. \.{DVIIMP}
provides the facility for removing fonts from |m_store| to make space for
additional fonts and then for restoring the removed fonts if this becomes
necessary. This process is complicated by the fact that we also want to
process the pages of the manuscript in reverse order.
\.{DVIIMP} handles this matter by reading the \.{DVI} postamble first to
get the desired |fnt_def1| information and by storing only the identifying
information at this time without storing the font rasters. An array
|font_state[f]| is used to keep a record of the state of all fonts with
the values set to 0 when the font identifying information is read. Later,
when the raster information is needed for a glyph in a non-loaded font,
the entire font is read in and the |font_state| value for this font is
changed to 1, with only the glyph actually requested being downloaded at
this time.
The location and state for each individual glyph in all the fonts used is
kept in a |glyph_ptr| array. This array is initially set to -1,
indicating that the referenced glyphs either do not exist or that they
have not yet been read into the |m_store| memory. The individual glyph
pointers are then set to positive values (actually, greater than 7) when
the font rasters are read in, recording the position in the |m_store|
where the glyph is stored. These numbers are negated when each individual
glyph is downloaded. Finally, if it becomes necessary to remove rasters
to make space for other fonts, the positive |glyph_ptr| values for all
glyphs of the removed fonts are set to zero without touching the negative
pointer values (which still indicate the downloaded or non-existant states
of the glyphs in question).
Removing the rasters for the downloaded glyphs does not in any way prevent the
continued use of these particular glyphs and no effort is made to reload any
particular font until a request is encountered for a removed non-down-loaded
glyph, as signalled by encountering a 0 value in the |glyph_ptr| array. At
this time, only the non-down-loaded glyphs of the reloaded font are restored,
with a possible substantial reduction in the space requirements as compared
with the font's initial needs.
@p procedure identify_font(@!e:integer); {|e| is an external font number}
var f:0..max_fonts;
@!p:integer; {length of the area/directory spec}
@!n:integer; {length of the font name proper}
@!c,@!q,@!d:integer; {check sum, scaled size, and design size}
@!r:0..name_length; {index into |cur_name|}
@!j,@!k:0..name_size; {indices into |names|}
@!m: integer; {available for use in |mag| effect caculations}
@!mismatch:boolean; {do names disagree?}
begin if nf=max_fonts then abort('DVIIMP capacity exceeded (max fonts=',
max_fonts:1,')!');
@.DVIIMP capacity exceeded...@>
font_num[nf]←e; f←0;
while font_num[f]≠e do incr(f);
if f<nf then if show_flag then
begin print_ln('---this font was already defined!');
@.this font was already defined@>
end
else begin if f=nf then if show_flag then
print_ln('---this font wasn''t loaded before!');
@.this font wasn't loaded before@>
@<Read the font parameters into position for font |nf|@>;
@<Verify |font_scaled_size| and |font_design_size| for size@>;
end
else @<Check that the current font definition matches the old one@>;
font_state[nf]←0; {font identified but not read in}
incr(nf); {signalling completion of identification}
@ @<Read the font parameters into position for font |nf|...@>=
c←signed_quad; font_check_sum[nf]←c;@/
q←signed_quad; font_scaled_size[nf]←q;@/
d←signed_quad; font_design_size[nf]←d;@/
p←get_byte; font_dir_length[nf]←p;@/
n←get_byte; font_name_length[nf]←n;@/
if font_name[nf]+n+p>name_size then
abort('DVIIMP capacity exceeded (name size=',name_size:1,')!');
@.DVIIMP capacity exceeded...@>
font_name[nf+1]←font_name[nf]+n+p;
if showing then print(': ')
{when |showing| is true, the font number has already been printed}
else if show_flag then print('Font ',e:1,': ');
if n+p=0 then print('null font name!')
@.null font name@>
else for k←font_name[nf] to font_name[nf+1]-1 do names[k]←get_byte;
incr(nf);
{|if show_flag then |}
print_font(nf-1);
decr(nf)
@<Verify |font_scaled_size| and |font_design_size| for size@>=
if (q≤0)∨(q≥@'1000000000) then
print('---may not load, bad scale (',q:1,')!')
@.bad scale@>
else if (d≤0)∨(d≥@'1000000000) then
print('---may not load, bad design size (',d:1,')!')
@.bad design size@>
else print('---had been identified.');
******* used in identify_font ******
@ @<Process the font definitions...@>=
repeat k←get_byte;
if (k≥fnt_def1)∧(k<fnt_def1+4) then
begin p←first_par(k); identify_font(p); k←nop;
end;
until k≠nop;
if k≠post_post then
print_ln('byte ',cur_loc-1:1,' is not postpost!')
@.byte n is not postpost@>
****** end of identify_font section ****
@p procedure free_space; {zero affected |m_store| area and + valued |glyph_ptr|'s}
var i,j: integer;
begin
j←cur_font mod m_m_num; {defining section of |m_store| to be cleared}
for i←0 to max_glyphs do
if (glyph_ptr[i]div m_store_size) = j then
if glyph_ptr[i] >0 then glyph_ptr[i]←0; {marking glyphs as removed}
for i←0 to m_store_size do m_store[j,i]←0; {marking space as available}
s_i[j]←0; {preparing to start at the beginning}
end;
@ @procedure get_gf_file;
var
@!p:integer; {length of the area/directory spec}
@!n:integer; {length of the font name proper}
@!c,@!q,@!d:integer; {check sum, scaled size, and design size}
@!r:0..name_length; {index into |cur_name|}
@!j,@!k:0..name_size; {indices into |names|}
@!m: integer; {available for use in |mag| effect caculations}
@!mismatch:boolean; {do names disagree?}
begin
p←font_dir_length[cur_font];
n←font_name_length[cur_font];
@<Move font name into the |cur_name| string@>;
open_gf_file;
if eof(gf_file) then
begin print(' font '); print_font(cur_font);
print_extension(cur_font);
print_ln('---not loaded, file can''t be opened!')
end
@.GF file can\'t be opened@>
if s_i[cur_font mod m_m_num] > m_store_size-400*font_m_val[cur_font] then
free_space;
end;
****** end of get_gf_file *****
THIS HAS BEEB FIXED IN PAGE7.CH
@<Move font name into the |cur_name| string@>=
for k←1 to name_length do cur_name[k]←' ';
if p=0 then
begin for k←1 to default_directory_name_length do
cur_name[k]←default_directory[k];
r←default_directory_name_length;
end
else r←0;
for k←font_name[cur_font] to font_name[cur_font+1]-1 do
begin incr(r);
if r+4>name_length then
abort('DVIIMP capacity exceeded (max font name length=',
name_length:1,')!');
@.DVIIMP capacity exceeded...@>
if (names[k]≥"a")∧(names[k]≤"z") then
cur_name[r]←xchr[names[k]-@'40]
else cur_name[r]←xchr[names[k]];
end;
cur_name[r+1]←'.'; cur_name[r+2]←'G'; cur_name[r+3]←'F'; {|cur_name[r+4]←'M';|}
**** end of modules needed by get_gf_file ******
@p procedure reload_font;
var k:integer; {index for loops}
@!c: integer; { used it index character number}
@!o:integer; {used to hold |gf| commands}
@!p:integer; {used to hold |gf| parameter}
@!a:integer; {used to hold |gf| parameter}
@!del_m:integer; {used to hold |gf| parameter}
@!del_n:integer; {used to hold |gf| parameter}
begin
if s_i[cur_font mod m_m_num] > m_store_size-400*font_m_val[cur_font] then
free_space;
get_gf_file;
@ @<Skip over the preamble@>;
@ @<Restow glyph rasters that have not been downloaded@>;
font_state[cur_font]←1; {signalling that font is loaded}
end;
***** end of reload_font ********
@ @<Skip over the preamble@>=
o←gf_byte; {fetch the first byte}
if o≠pre then goto 9997;
o←gf_byte; {fetch the identification byte}
if o≠gf_id_byte then goto 9997;
o←gf_byte; {fetch the length of the introductory comment}
while o>0 do
begin decr(o); p←gf_byte;
end;
@ @<Restow glyph rasters that have not been downloaded@>=
repeat gf_prev_ptr←cur_gf_loc;
@<Pass |no_op|, |xxx| and |yyy| commands@>;
if (o=boc) or (o=boc1) then
begin
if o=boc then begin @<Read the |boc| information@> end
else begin @<Read the |boc1| information@>;
end;
if glyph_ptr[data_base[cur_font]+c]<0 then
begin @<Pass over the raster details@>; {this glyph has been downloaded}
end else
begin
@<Stow the |boc| or |boc1| information@>;
glyph_ptr[data_base[cur_font]+c]←
(cur_font mod m_m_num)*m_store_size+s_i[cur_font mod m_m_num];
{save mask start address}
{|print_ln(' cur font',cur_font:1,' c= ',c:1,' s_i= ',s_i[i_f]:1);|}
@<Stow the glyph details@>;
end;
end;
until o=post;
@ @<Read the |boc| information@>=
char_code←gf_signed_quad;
p←gf_signed_quad;
c←char_code mod 256;
if c<0 then c←c+256;
{|print('[',c:1,']');|}
if char_code≠c then
print(' in family ',(char_code-c) div 256 : 1);
min_m←gf_signed_quad; max_m←gf_signed_quad;
min_n←gf_signed_quad; max_n←gf_signed_quad;
@ @<Read the |boc1| information@>=
char_code←gf_byte;
p←-1;
c←char_code;
del_m←gf_byte; max_m←gf_byte;
del_n←gf_byte; max_n←gf_byte;
max_m-min_m+1←del_m+1;
min_m←max_m-del_m
max_n-min_n+1←del_n+1;
@ @<Stow the |boc| or |boc1| information@>=
stow_signed_pair(max_m-min_m+1);
stow_signed_pair(-min_m); {this is the initial |m| value}
stow_signed_pair(max_n-min_n+1);
stow_signed_pair(max_n);
@ @<Pass over the raster details@>= {this glyph has been downloaded}
o←gf_byte;
while o≠eoc do
begin
a←cur_gf_loc;
while (o<paint1) or (o=skip0) or ((o≥new_row_0) and (o≤new_row_0+164)) do
o←gf_byte;
if (o=paint1) or (o=skip1) then
begin
p←gf_byte; o←gf_byte;
end else
if o=xxx1 then {\MF\ will not do this but it is allowed}
begin p←gf_byte;
while p>0 do
begin q←gf_byte; decr(p);
end;
o←gf_byte;
end;
end;
@ @<Stow the |boc| or |boc1| information@>=
stow_signed_pair(max_m-min_m+1);
stow_signed_pair(-min_m); {this is the initial |m| value}
stow_signed_pair(max_n-min_n+1);
stow_signed_pair(max_n);
***** end ofmodules called by reload_font ****
@ @<Finish a command that changes the current font...@>=
font_num[nf]←p; cur_font←0;
while font_num[cur_font]≠p do incr(cur_font);
if font_state[cur_font]=0 then
begin get_gf_file;
if in_gf then font_state[cur_font]←1 else font_state[cur_font]←-1;
end;
im_byte(set_family); im_byte(cur_font);
if show_flag then print_ln(' family has been changed to ',cur_font:1);
if showing then
begin print(' current font is '); print_font(cur_font);
end;
goto done
****** end of finish a command that changes the current font ***
begin
g←glyph_ptr[data_base[cur_font]+p];
if show_flag then
print(' (',f_i_r:1,',',glyph_ptr[data_base[cur_font]+p]-big_f_i_r:1,')');
if g=0 then reload_font; {font must be reloaded}
if g>0 then do_im_bgly(p);
@<Resyncronize@>;
im_byte(p); {this sends glyph p of current family}
hhi←hhi+pixel_width[data_base[cur_font]+p];
end;
***** end of modified section in Finish a command....a character... ****
@<Handle a font with more than 128 glyphs@>=
dv3 is my start of a fix
*******dv2 is the good back-up copy *****
PREFERRED VERSIONS OF THE CHANGES ARE TO GO AHEAD OF THIS LINE.
************ new font, unless there are problems@>=
begin
@<Move font name into the |cur_name| string@>;
if s_i[cur_font mod m_m_num] > m_store_size-16000 then
free_store_space;
open_gf_file;
if eof(gf_file) then
begin print(' font '); print_font(cur_font);
print_extension(cur_font);
print_ln('---not loaded, file can''t be opened!')
end
@.GF file can\'t be opened@>
else begin if (q≤0)∨(q≥@'1000000000) then
print('---not loaded, bad scale (',q:1,')!')
@.bad scale@>
else if (d≤0)∨(d≥@'1000000000) then
print('---not loaded, bad design size (',d:1,')!')
@.bad design size@>
else if in_gf(q) then @<Finish loading the new font info@>;
end;
if out_mode=errors_only then if show_flag then print_ln(' ');
end
***** decide where this is to go
if g=0 then reload_font; {font must be reloaded} THIS IS IN PLACE
@p procedure reload_font;
var k:integer; {index for loops}
@!c: integer; { used it index character number}
@!o:integer; {used to hold |gf| commands}
@!p:integer; {used to hold |gf| parameter}
@!a:integer; {used to hold |gf| parameter}
@!del_m:integer; {used to hold |gf| parameter}
@!del_n:integer; {used to hold |gf| parameter}
begin
if s_i[cur_font mod m_m_num] > m_store_size-400*font_m_val[cur_font] then
free_space;
get_gf_file;
@ @<Skip over the preamble@>;
@ @<Restow glyph rasters that have not been downloaded@>;
font_state[cur_font]←1; {signalling that font is loaded}
end;
procedure get_gf_file;
var
@!p:integer; {length of the area/directory spec}
@!n:integer; {length of the font name proper}
@!c,@!q,@!d:integer; {check sum, scaled size, and design size}
@!r:0..name_length; {index into |cur_name|}
@!j,@!k:0..name_size; {indices into |names|}
@!m: integer; {available for use in |mag| effect caculations}
@!mismatch:boolean; {do names disagree?}
begin
p←font_dir_length[nf];
n←font_name_length[nf];
@<Move font name into the |cur_name| string@>;
open_gf_file;
if eof(gf_file) then
begin print(' font '); print_font(cur_font);
print_extension(cur_font);
print_ln('---not loaded, file can''t be opened!')
end
@.GF file can\'t be opened@>
else begin if (q≤0)∨(q≥@'1000000000) then
print('---not loaded, bad scale (',q:1,')!')
@.bad scale@>
else if (d≤0)∨(d≥@'1000000000) then
print('---not loaded, bad design size (',d:1,')!')
@.bad design size@>
else if in_gf(q) then @<Finish loading the new font info@>;
end;
if out_mode=errors_only then if show_flag then print_ln(' ');
if s_i[cur_font mod m_m_num] > m_store_size-16000 then
free_space;
end;
THIS HAS BEEB FIXED IN PAGE7.CH
@<Move font name into the |cur_name| string@>=
for k←1 to name_length do cur_name[k]←' ';
if p=0 then
begin for k←1 to default_directory_name_length do
cur_name[k]←default_directory[k];
r←default_directory_name_length;
end
else r←0;
for k←font_name[cur_font] to font_name[cur_font+1]-1 do
begin incr(r);
if r+4>name_length then
abort('DVIIMP capacity exceeded (max font name length=',
name_length:1,')!');
@.DVIIMP capacity exceeded...@>
if (names[k]≥"a")∧(names[k]≤"z") then
cur_name[r]←xchr[names[k]-@'40]
else cur_name[r]←xchr[names[k]];
end;
cur_name[r+1]←'.'; cur_name[r+2]←'G'; cur_name[r+3]←'F'; {|cur_name[r+4]←'M';|}
@ @<Read the |boc| information@>=
char_code←gf_signed_quad;
p←gf_signed_quad;
c←char_code mod 256;
if c<0 then c←c+256;
{|print('[',c:1,']');|}
if char_code≠c then
print(' in family ',(char_code-c) div 256 : 1);
min_m←gf_signed_quad; max_m←gf_signed_quad;
min_n←gf_signed_quad; max_n←gf_signed_quad;
@ @<Read the |boc1| information@>=
char_code←gf_byte;
p←-1;
c←char_code;
del_m←gf_byte; max_m←gf_byte;
del_n←gf_byte; max_n←gf_byte;
max_m-min_m+1←del_m+1;
min_m←max_m-del_m
max_n-min_n+1←del_n+1;
@ @<Stow the |boc| or |boc1| information@>=
stow_signed_pair(max_m-min_m+1);
stow_signed_pair(-min_m); {this is the initial |m| value}
stow_signed_pair(max_n-min_n+1);
stow_signed_pair(max_n);
@ @<Pass over the raster details@>= {this glyph has been downloaded}
o←gf_byte;
while o≠eoc do
begin
a←cur_gf_loc;
while (o<paint1) or (o=skip0) or ((o≥new_row_0) and (o≤new_row_0+164)) do
o←gf_byte;
if (o=paint1) or (o=skip1) then
begin
p←gf_byte; o←gf_byte;
end else
if o=xxx1 then {\MF\ will not do this but it is allowed}
begin p←gf_byte;
while p>0 do
begin q←gf_byte; decr(p);
end;
o←gf_byte;
end;
end;
NOTE**** change line in `define_font' page11 line 85 to
if f=nf then @<Load the new font, unless there are problems@>
or better yet also add a test of font_state.
*******working here*****
@p function in_gf(@!z:integer):boolean; {input \.{GF} data or return |false|}
label 9997, {go here when the format is bad}
9998, {go here when the information cannot be loaded}
9999; {go here to exit}
var k:integer; {index for loops}
@!lh:integer; {length of the header data, in four-byte words}
@!nw:integer; {number of words in the width table}
@!wp:0..max_glyphs; {new value of |width_ptr| after successful input}
@!alpha,@!beta:integer; {quantities used in the scaling computation}
@!c: integer; { used it index character number}
@!o:integer; {used to hold |gf| commands}
@!p:integer; {used to hold |gf| parameter}
@!a:integer; {used to hold |gf| parameter}
@!del_m:integer; {used to hold |gf| parameter}
@!del_n:integer; {used to hold |gf| parameter}
begin
if font_state[cur_font]=-1 then
begin
if ¬find_gf_postamble then goto 9997;
read_gf_postamble;
@<Check |width| table and |goto 9997| if there is a problem@>;
@<Convert and store the width values@>;
@<Process the gf preamble@>;
@<Stow all of the glyph-raster info@>;
{|tabulate;|} {Used to show actual bit map of glyph}
{|print_ln(' glyph-raster done');|}
width_ptr←wp;
in_gf←true; goto 9999;
end
else @<Do a glyph-by-glyph relocate@>;
9997: print_ln('---not loaded, GF file is bad');
@.GF file is bad@>
9998: in_gf←false;
9999: end;
@ @<Do a glyph by glyph relocate@>=
@<Process the gf preamble@>;
repeat gf_prev_ptr←cur_gf_loc;
@<Pass |no_op|, |xxx| and |yyy| commands@>;
if (o=boc) or (o=boc1) then
begin
if o=boc then begin @<Save the |boc| information@> end
else begin @<Save the |boc1| information@>;
end;
if glyph_ptr[data_base[cur_font]+c]>0 then
@<Stow the saved information@>;
glyph_ptr[data_base[nf]+c]←(nf mod m_m_num)*m_store_size+s_i[nf mod m_m_num];
{save mask start address}
{|print_lndv.psc',nf:1,' c= ',c:1,' s_i= ',s_i[i_f]:1);|}
@<Stow the glyph details@>;
end;
until o=post;
if g>0 then
begin
if b_fnt_loc[cur_font]=-1 then restore_font(cur_font);
do_im_bgly(p);
end;
@ @<Set init...@>=
for i←0 to max_fonts do
begin b_fnt_loc[i]←-1; {beginning |m_store| location of font rasters}
e_fnt_loc[i]←-1; {actually the |m_store location after the end}
end;
for i←0 to m_num do
begin b_empty[i]←0; e_empty[i]←m_store_size;
end;
procedure restore_font (f:integer);
var m,n,x:integer;
begin
m←f mod m_m_num;
n←b_empty[m];
if e_empty[m]-b_empty[m]<100 then @<Find and remove interfering font@>;
while n<e_empty-1 do
end;
@ @<Find and overwrite interfering font@>
begin
if e_empty[m]< m_store_size then {another font in way}
begin
x←o;
while (x mod m_m_num ≠ m) or (b_fnt_loc[x] ≠ e_empty[m]) do incr(x);
end
else
begin {we will have to go back to the start}
end;
end;
@ @<Identify the font to be overwritten@>=
over_write_font←0;
while (over_write_font mod m_m_mum) ≠ (cur_font mod m_m_num) and
(b_fnt_loc[over_write_font] ≠ empty[cur_font mod m_m_num]) then
incr(over_write_font);
end;
********** All sections to be used should be before theis location
@p procedure define_font(@!e:integer); {|e| is an external font number}
var f:0..max_fonts;
@!p:integer; {length of the area/directory spec}
@!n:integer; {length of the font name proper}
@!c,@!q,@!d:integer; {check sum, scaled size, and design size}
@!r:0..name_length; {index into |cur_name|}
@!j,@!k:0..name_size; {indices into |names|}
@!m: integer; {available for use in |mag| effect caculations}
@!mismatch:boolean; {do names disagree?}
begin if nf=max_fonts then abort('DVIIMP capacity exceeded (max fonts=',
max_fonts:1,')!');
@.DVIIMP capacity exceeded...@>
font_num[nf]←e; f←0;
while font_num[f]≠e do incr(f);
@<Read the font parameters into position for font |nf|, and
print the font name@>;
if in_postamble then
begin if f<nf then if show_flag then
print_ln('---this font was already defined!');
@.this font was already defined@>
end
else begin if f=nf then if show_flag then
print_ln('---this font wasn''t loaded before!');
@.this font wasn't loaded before@>
end;
if f=nf then @<Load the new font, unless there are problems@>
else @<Check that the current font definition matches the old one@>;
end;
I wonder if you would care to comment on the following matter.
I am considering two different ways of handling 256-character fonts on the
Imagen. The basic difficulty is that the Imagen allows only 7 bits for the
character number and a 256-glyph font must, therefore, be handled as two
separate Imagen fonts. The choice of method of handling this matter will
depend upon the structure and intended use of the large fonts, of which I am
quite uninformed.
The straight forward method would be to assign characters 0 to 127 to one
font and to assign the rest to a second font. Since the glyphs will not
necessarily be read in serial order, this splitting would probably not be
done as the glyphs were read into internal store but would be left until
the glyphs were individually downloaded. A set_family command requiring
two extra bytes would then have to be sent to the IMP file for each
transition between the two fonts.
An alternate procedure would be to serially number the glyphs of each
large font as they are first used and to assign the first 128 used glyphs
to one font with the remaining to the second font and to generate a
translation table relating the two numbering systems. On the assumption
that the 128 first-used different glyphs would normally include most of
the frequently used glyphs, one would seldom have to switch to the
auxilliary font containing the remaining glyphs. Indeed, sparsely
populated large fonts might well collapse into a single font. The number
of set_family commands would be substantiolly reduced, but at the expense
of requiring that each glyph request be translated.